"use strict";
/**
 * @packageDocumentation
 * project: recursive-readdir-async
 * @author: m0rtadelo (ricard.figuls)
 * @license MIT
 * 2018
 */
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
    if (mod && mod.__esModule) return mod;
    var result = {};
    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
    __setModuleDefault(result, mod);
    return result;
};
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.list = exports.readFile = exports.stat = exports.PATH = exports.FS = exports.TREE = exports.LIST = void 0;
/** @readonly constant for mode LIST to be used in Options */
exports.LIST = 1;
/** @readonly constant for mode TREE to be used in Options */
exports.TREE = 2;
/**
 * native FS module
 * @see https://nodejs.org/api/fs.html#fs_file_system
 * @external
 */
const _fs = __importStar(require("fs"));
/** native node fs object */
exports.FS = _fs;
/**
 * native PATH module
 * @external
 * @see https://nodejs.org/api/path.html#path_path
 */
const _path = __importStar(require("path"));
/** native node path object */
exports.PATH = _path;
let pathSimbol = '/';
/**
 * Returns a Promise with Stats info of the item (file/folder/...)
 * @param file the name of the object to get stats from
 * @returns {Promise<fs.Stats>} stat object information
 * @async
 */
function stat(buffer) {
    return __awaiter(this, void 0, void 0, function* () {
        return new Promise(function (resolve, reject) {
            exports.FS.stat(buffer, function (err, stats) {
                if (err) {
                    reject(err);
                }
                else {
                    resolve(stats);
                }
            });
        });
    });
}
exports.stat = stat;
/**
 * Returns a Promise with content (data) of the file
 * @param file the name of the file to read content from
 * @param encoding format for returned data (ascii, base64, binary, hex, ucs2/ucs-2/utf16le/utf-16le,
 *  utf8/utf-8, latin1). Default: base64
 * @returns {Promise<string>} data content string (base64 format by default)
 * @async
 */
function readFile(file, encoding = 'base64') {
    return __awaiter(this, void 0, void 0, function* () {
        return new Promise(function (resolve, reject) {
            exports.FS.readFile(file, { encoding }, function (err, data) {
                if (err) {
                    reject(err);
                }
                else {
                    resolve(data);
                }
            });
        });
    });
}
exports.readFile = readFile;
/**
 * Returns if an item should be added based on include/exclude options.
 * @param path the item fullpath
 * @param settings the options configuration to use
 * @returns {boolean} if item must be added
 * @private
 */
function checkItem(path, settings) {
    if (settings.exclude) {
        for (const value of settings.exclude) {
            if (path.includes(value)) {
                return false;
            }
        }
    }
    return true;
}
/**
 * Adds optional keys to item
 * @param obj the item object
 * @param file the filename
 * @param settings the options configuration to use
 * @param deep The deep level
 * @returns void
 * @private
 */
function addOptionalKeys(obj, file, settings, deep) {
    if (settings.extensions) {
        obj.extension = (exports.PATH.extname(file)).toLowerCase();
    }
    if (settings.deep) {
        obj.deep = deep;
    }
}
/**
 * Reads content and creates a valid IBase collection
 * @param rpath Path relative to
 * @param data Model
 * @param settings the options configuration to use
 * @param deep The deep level
 * @param resolve Promise
 * @param reject Promise
 * @returns void
 */
function read(rpath, data, settings, deep, resolve, reject) {
    exports.FS.readdir(rpath, 'buffer', function (error, files) {
        // If error reject them
        if (error) {
            reject(error);
        }
        else {
            const removeExt = (file) => {
                const extSize = exports.PATH.extname(file).length;
                return file.substring(0, file.length - (extSize > 0 ? extSize : 0));
            };
            // Iterate through elements (files and folders)
            for (const file of files) {
                const path = rpath + (rpath.endsWith(pathSimbol) ? '' : pathSimbol);
                const obj = {
                    name: file.toString(),
                    nameb: file,
                    title: removeExt(file.toString()),
                    path: rpath,
                    pathb: Buffer.from(rpath),
                    fullname: path + file.toString(),
                    fullnameb: Buffer.concat([Buffer.from(path), file]),
                };
                if (checkItem(obj.fullname, settings)) {
                    addOptionalKeys(obj, file.toString(), settings, deep);
                    data.push(obj);
                }
            }
            // Finish, returning content
            resolve(data);
        }
    });
}
/**
 * Returns a Promise with an objects info array
 * @param path the item fullpath to be searched for
 * @param settings the options configuration to use
 * @param deep folder depth value
 * @returns {Promise<IBase[]>} the file object info
 * @private
 */
function myReaddir(path, settings, deep) {
    return __awaiter(this, void 0, void 0, function* () {
        const data = [];
        return new Promise(function (resolve, reject) {
            try {
                // Asynchronously computes the canonical pathname by resolving ., .. and symbolic links.
                exports.FS.realpath(path, function (err, rpath) {
                    if (err || settings.realPath === false) {
                        rpath = path;
                    }
                    // Normalizes windows style paths by replacing double backslahes with single forward slahes (unix style).
                    if (settings.normalizePath) {
                        rpath = normalizePath(rpath);
                    }
                    // Reading contents of path
                    read(rpath, data, settings, deep, resolve, reject);
                });
            }
            catch (err) {
                // If error reject them
                reject(err);
            }
        });
    });
}
/**
 * Normalizes windows style paths by replacing double backslahes with single forward slahes (unix style).
 * @param path windows/unix path
 * @return {string} normalized path (unix style)
 * @private
 */
function normalizePath(path) {
    return path.toString().replace(/\\/g, '/');
}
/**
     * Search if the fullname exist in the include array
     * @param fullname - The fullname of the item to search for
     * @param settings the options to be used
     * @returns true if exists
     */
function exists(fullname, settings) {
    if (settings.include) {
        for (const value of settings.include) {
            if (fullname.includes(value)) {
                return true;
            }
        }
    }
    return false;
}
/**
   * Removes paths that not match the include array
   * @param settings the options to be used
   * @param content items list
   * @returns void
   */
function onlyInclude(settings, content) {
    if (settings.include && settings.include.length > 0) {
        for (let i = content.length - 1; i > -1; i--) {
            const item = content[i];
            if (settings.mode === exports.TREE && item.isDirectory && item.content)
                continue;
            if (!exists(item.fullname, settings)) {
                content.splice(i, 1);
            }
        }
    }
}
/**
 * Returns an array of items in path
 * @param path path
 * @param settings the options to be used
 * @param progress callback progress
 * @param deep deep index information
 * @returns {object[]} array with file information
 * @private
 */
function listDir(path, settings, progress, deep = 0) {
    return __awaiter(this, void 0, void 0, function* () {
        let content;
        try {
            content = yield myReaddir(path, settings, deep);
        }
        catch (err) {
            return { 'error': err, 'path': path };
        }
        if (settings.stats || settings.recursive || !settings.ignoreFolders ||
            settings.readContent || settings.mode === exports.TREE) {
            content = yield statDir(content, settings, progress, deep);
        }
        onlyInclude(settings, content);
        return content;
    });
}
/**
 * Returns an object with all items with selected options
 * @param collection items list
 * @param settings the options to use
 * @param progress callback progress
 * @param deep folder depth
 * @returns {object[]} array with file information
 * @private
 */
function statDir(collection, settings, progress, deep) {
    return __awaiter(this, void 0, void 0, function* () {
        let isOk = true;
        for (let i = collection.length - 1; i > -1; i--) {
            try {
                collection = yield statDirItem(collection, i, settings, progress, deep);
                if (progress !== undefined) {
                    isOk = !progress(collection[i], collection.length - i, collection.length);
                }
            }
            catch (err) {
                collection[i].error = err;
            }
            if ((collection[i].isDirectory && settings.ignoreFolders &&
                !(collection[i].content) && collection[i].error === undefined) || !isOk) {
                collection.splice(i, 1);
            }
        }
        return collection;
    });
}
/**
 * Returns an object with updated item information
 * @param collection items list
 * @param i index of item
 * @param settings the options to use
 * @param progress callback progress
 * @param deep folder depth
 * @returns {object[]} array with file information
 * @private
 */
function statDirItem(collection, i, settings, progress, deep) {
    return __awaiter(this, void 0, void 0, function* () {
        const stats = yield stat(collection[i].fullnameb);
        collection[i].isDirectory = stats.isDirectory();
        if (settings.stats) {
            collection[i].stats = stats;
        }
        if (settings.readContent && !collection[i].isDirectory) {
            collection[i].data = yield readFile(collection[i].fullnameb, settings.encoding);
        }
        if (collection[i].isDirectory && settings.recursive) {
            const item = collection[i];
            if (settings.mode === exports.LIST) {
                const result = yield listDir(item.fullname, settings, progress, deep + 1);
                if (result.length) {
                    collection = collection.concat(result);
                }
            }
            else {
                item.content = yield listDir(item.fullname, settings, progress, deep + 1);
                if (item.content && item.content.length === 0) {
                    item.content = undefined;
                }
            }
        }
        return collection;
    });
}
/**
 * Returns a javascript object with directory items information (non blocking async with Promises)
 * @param path the path to start reading contents
 * @param [options] options (mode, recursive, stats, ignoreFolders)
 * @param [progress] callback with item data and progress info for each item
 * @returns promise array with file/folder information
 * @async
 */
function list(path, options, progress) {
    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
    return __awaiter(this, void 0, void 0, function* () {
        // options skipped?
        if (typeof options === 'function') {
            progress = options;
        }
        // Setting default settings
        const settings = {
            mode: ((_a = options) === null || _a === void 0 ? void 0 : _a.mode) || exports.LIST,
            recursive: ((_b = options) === null || _b === void 0 ? void 0 : _b.recursive) === undefined ? true : options.recursive,
            stats: ((_c = options) === null || _c === void 0 ? void 0 : _c.stats) === undefined ? false : options.stats,
            ignoreFolders: ((_d = options) === null || _d === void 0 ? void 0 : _d.ignoreFolders) === undefined ? true : options.ignoreFolders,
            extensions: ((_e = options) === null || _e === void 0 ? void 0 : _e.extensions) === undefined ? false : options.extensions,
            deep: ((_f = options) === null || _f === void 0 ? void 0 : _f.deep) === undefined ? false : options.deep,
            realPath: ((_g = options) === null || _g === void 0 ? void 0 : _g.realPath) === undefined ? true : options.realPath,
            normalizePath: ((_h = options) === null || _h === void 0 ? void 0 : _h.normalizePath) === undefined ? true : options.normalizePath,
            include: ((_j = options) === null || _j === void 0 ? void 0 : _j.include) || [],
            exclude: ((_k = options) === null || _k === void 0 ? void 0 : _k.exclude) || [],
            readContent: ((_l = options) === null || _l === void 0 ? void 0 : _l.readContent) === undefined ? false : options.readContent,
            encoding: ((_m = options) === null || _m === void 0 ? void 0 : _m.encoding) || undefined,
        };
        // Setting pathSimbol if normalizePath is disabled
        if (settings.normalizePath === false) {
            pathSimbol = exports.PATH.sep;
        }
        else {
            pathSimbol = '/';
        }
        // Reading contents
        return listDir(path, settings, progress);
    });
}
exports.list = list;
